Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@commands/logs.go`:
- Around line 35-37: The current handler silently swallows JSON encoding
failures by returning false on encoder.Encode(entry) and later returning
NewSuccessResponse("done"); modify the error path so encode failures are
propagated instead of masked: when encoder.Encode(entry) returns an error,
return a failure value (e.g., propagate the error to the caller or return a
NewErrorResponse with err.Error()) rather than returning false, and ensure the
function no longer returns NewSuccessResponse("done") when an encode error
occurred. Update the code around encoder.Encode(entry) to surface the actual err
and stop further processing, and adjust any callers of this function to handle
the propagated error if needed.

In `@devices/ios.go`:
- Around line 1667-1717: StreamLogs currently calls d.getEnhancedDevice()
directly which can fail on iOS 17+ if the tunnel isn't started; mirror other
methods (Reboot, LaunchApp, TerminateApp) by calling d.startTunnel() first and
returning any error. Modify StreamLogs to invoke d.startTunnel(), check and
return its error, then proceed to call d.getEnhancedDevice() and the rest of the
existing logic; ensure you reference the IOSDevice methods startTunnel and
getEnhancedDevice and preserve existing defer conn.Close() behavior.

---

Nitpick comments:
In `@commands/logs.go`:
- Around line 31-33: The PID-check treats 0 as a valid filter because it uses
req.PID >= 0; change the filter to distinguish "unset" from a real PID by making
req.PID a pointer (*int) or by using -1 as the explicit unset sentinel; then
update the check in the logs filtering code to something like "if req.PID != nil
&& entry.PID != *req.PID { return true }" (or if using sentinel: "if req.PID !=
-1 && entry.PID != req.PID { return true }") and adjust flag/constructors that
populate req.PID accordingly so callers can actually signal "no PID filter".

Verify each finding against the current code and only fix it if needed.

Duplicate comments:
In `@commands/logs.go`:
- Around line 34-36: The JSON encode failures are being swallowed where
encoder.Encode(entry) is called; change the callback to propagate the error
instead of returning a bool success sentinel: when encoder.Encode(entry) (and
the similar block at 43-47) returns an error, return that error (or set a named
err variable and break) so the caller can detect and surface the failure, and
update the outer caller/return path to return the error rather than always
returning success; reference the encoder.Encode(entry) calls and the surrounding
callback/handler to locate and update the code paths.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@devices/simulator.go`:
- Around line 1072-1116: The code currently treats any json.Decoder errors as
normal end-of-stream and kills the child without reaping it; update the
log-stream handling so that failures from decoder.Token() or decoder.Decode()
that are not io.EOF are returned as errors and the child is reaped: after
calling cmd.Process.Kill() invoke cmd.Wait() and include its error in the
returned fmt.Errorf; when decoder.Decode() returns io.EOF treat it as normal
end-of-stream, but for other errors return them (again ensuring cmd.Wait() is
called and its error combined); finally, don't ignore the result of cmd.Wait()
at the end—return any non-nil wait error. Add the io import and reference
functions/values like cmd.Start, decoder.Token, decoder.Decode,
cmd.Process.Kill, cmd.Wait, simctlLogEntry, and onLog when making these fixes.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@devices/android.go`:
- Around line 1408-1450: The PID→process map is created once by calling
getPidToProcessMap() before starting adb logcat, so processes started after the
stream begins never get resolved; update the code inside the scanner loop to
refresh or requery the PID map when needed (e.g., call getPidToProcessMap()
again on a cache miss or at a regular interval) before assigning entry.Process,
referencing pidMap, getPidToProcessMap(), the scanner loop that iterates
parseLogcatLine(line), and the LogEntry.Process assignment so new processes
launched after log streaming starts will be correctly resolved for --process
filtering.
- Around line 1424-1459: StreamLogs currently swallows scanner and subprocess
errors; change it to propagate them: after the scanner loop check scanner.Err()
and return it if non-nil (unless we intentionally stopped because onLog returned
false), and after breaking/killing the child call cmd.Wait() and return its
error instead of always returning nil; use the onLog return value to distinguish
an intentional stop (treat as nil) from actual errors, and ensure any error from
cmd.Wait() is returned when the stop was not intentional. Reference: StreamLogs
function, scanner variable, onLog callback, and cmd.Wait()/cmd.Process.Kill()
calls.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@devices/ios.go`:
- Around line 1632-1673: The StreamLogs method calls the callback onLog without
checking for nil which can panic; add a nil guard around the invocation in
IOSDevice.StreamLogs so callers may pass nil safely. Specifically, in function
StreamLogs (method on type IOSDevice) replace the unconditional call to
onLog(out) with a check like: if onLog != nil { if !onLog(out) { return nil } }
so that when onLog is nil the log loop continues/terminates normally without
invoking a nil function pointer.

---

Nitpick comments:
In `@devices/simulator.go`:
- Around line 925-932: The error paths repeatedly call cmd.Process.Kill()
followed by cmd.Wait() and propagate wait errors (e.g., the blocks handling
token errors around the token/json.Delim checks), so extract that plumbing into
a small helper (for example killAndWait or terminateCmd) that accepts the
*exec.Cmd and returns the wait error (or combined error), then replace each
duplicated pair (the occurrences using cmd.Process.Kill() and cmd.Wait() in the
token read/expect blocks) with a single call to that helper and use its returned
error in the fmt.Errorf calls to keep semantics identical while removing
duplication.